home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 240_01 / ciao.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-07-29  |  29.3 KB  |  995 lines
  1. /*
  2. **   ciao.c
  3. **   sept 10, 1986, by david c. oshel, ames, iowa
  4. **
  5. **  ----->  COMPILE USING UNSIGNED CHAR
  6. **
  7. **   Console input and output for the 101% IBM PC clone.  This is the first
  8. **   module in my CIAO.LIB library.
  9. **
  10. **   These are FAST primitives to read from and write to the IBM video RAM.
  11. **   Ignores the ROM-BIOS except to set text mode and/or to read or set the 
  12. **   machine cursor (see just below).
  13. **
  14. **   The module is self-initializing.  Vid_init(n) is only required to set
  15. **   a particular mode, e.g., vid_init(3) to set 80x25 color text.  The
  16. **   requested mode is only set if the hardware supports it, and only
  17. **   monochrome mode 7 and cga modes 2 or 3 are valid.  No graphics modes.
  18. **
  19. **   Global functions which ALTER THE CONTENTS OF THE SCREEN test the 
  20. **   initialized flag.  In general, static, ROM-BIOS and cursor functions 
  21. **   do NOT test the flag.  If the flag is still zero, vid_init executes.
  22. **
  23. **   The machine cursor and the video RAM write location ("soft cursor")
  24. **   are independent, but are synchronized by default.  See setsynch fn.
  25. **
  26. **   Compiler is Microsoft C ver. 4.00, but this particular module should be 
  27. **   fairly portable to another compiler (such as Microsoft C ver. 3.00). 
  28. **
  29. */
  30.  
  31.  
  32. /*=======================================================================*
  33.      There are 16 public Video Attribute Registers:  vid[0] ... vid[15]
  34.  
  35.      The Clairol routine (CLAIROL.OBJ) recognizes four major message
  36.      levels, associated with vid[0], vid[1], vid[2], vid[3].  This is
  37.      the popout window that allows user access to the first four video
  38.      registers (only).
  39.  
  40.      Programmers have access to all 16 registers at all times, using
  41.      the CLAIROL.H header file.
  42.  
  43.      Clairol           VidReg   ^ commands that set the attribute
  44.      -------------------------------------------------------------------
  45.      Normal            vid[0]   wputs("^0"); wputs("^");
  46.      Bold              vid[1]   wputs("^1"); 
  47.      Emphasis          vid[2]   wputs("^2"); 
  48.      Attention!        vid[3]   wputs("^3"); 
  49.  
  50.                        vid[4]   wputs("^4");
  51.                        .
  52.                        .
  53.                        .
  54.                        vid[ 9]  wputs("^9");
  55.                        vid[10]  wputs("^Ω"); keystroke is ALT 234
  56.                        vid[11]  wputs("^δ");      "       ALT 235
  57.                        vid[12]  wputs("^∞");      "       ALT 236
  58.                        vid[13]  wputs("^φ");      "       ALT 237
  59.                        vid[14]  wputs("^ε");      "       ALT 238
  60.                        vid[15]  wputs("^∩");      "       ALT 239
  61.  
  62.  
  63.      The DEFAULT contents of these registers is as follows:
  64.  
  65.      Contents      *Color/Graphics Adapt.   Monochrome Adapter
  66.      -----------------------------------------------------------------
  67.      Normal         brite white on blue     normal
  68.      Bold           brite yellow on black   bright normal
  69.      Emphasis       brite blue on white     reverse
  70.      Attention      blink br. white on red  blinking reverse
  71.  
  72.      vid[ 4]       *red, 4                  underline
  73.      vid[ 5]        magenta, 5              bright underline    
  74.      vid[ 6]        dark yellow, 6          blinking normal
  75.      vid[ 7]        ordinary white, 7       blinking underline
  76.      vid[ 8]        dark grey, 8            blinking bright normal 
  77.      vid[ 9]        brite blue, 9           blinking bright underline
  78.      vid[10]        brite green, 0x0a       normal
  79.      vid[11]        brite cyan, 0x0b        normal
  80.      vid[12]        brite red, 0x0c         normal
  81.      vid[13]        brite magenta, 0x0d     normal
  82.      vid[14]        brite yellow, 0x0e      normal
  83.      vid[15]        brite white, 0x0f       normal
  84.  
  85.      *The default background is black for registers vid[4]..vid[15], and
  86.       blink is off.
  87.  
  88.  *=======================================================================*/
  89.  
  90.  
  91.  
  92. #define LINT_ARGS
  93.  
  94. #include <alloc.h>     /* _fmalloc(), _ffree()  */
  95. #include <conio.h>      /* direct console: putch(), getch(), etc */
  96.  
  97. #include "ciao.h"
  98.  
  99. /* these defines are for ciao.c alone; they are local, not for ciao.h
  100. */
  101.  
  102.  
  103. #define SCRLIM 4000                         /* 80x25 chars & attrs in screen */
  104. #define TOPX 0                              /* 80x25 screen margin defaults  */
  105. #define TOPY 0
  106. #define BTMX 79
  107. #define BTMY 24
  108. #define GOXY (2*(col+(row*80)))             /* yields absolute screen address */
  109. #define SPC ' '                             /* blank char, for clreol(), etc. */
  110.  
  111. /* monochrome monitor attributes :----------------*/
  112.  
  113. #define INV '\000'   /* invisible                 */
  114. #define UNL '\001'   /* underline                 */
  115. #define NRM '\007'   /* normal                    */
  116. #define BRU '\011'   /* bright underline          */
  117. #define BRN '\017'   /* bright normal             */
  118. #define RVR '\160'   /* reverse                   */
  119. #define BLU '\201'   /* blinking underline        */
  120. #define BLN '\207'   /* blinking normal           */
  121. #define BBU '\211'   /* blinking bright underline */
  122. #define BBN '\217'   /* blinking bright normal    */
  123. #define BLR '\360'   /* blinking reverse          */
  124.  
  125.  
  126. /*
  127. ** globals
  128. */
  129.  
  130.  
  131. int vid[16] =  /* vid_init() changes this table if cga */
  132. {
  133.     NRM, BRN, RVR, BLR, 
  134.     UNL, BRU, BLN, BLU, 
  135.     BBN, BBU, NRM, NRM,
  136.     NRM, NRM, NRM, NRM
  137. };
  138.  
  139. int vid_mode = 7;                  /* monochrome is default */
  140. int rasterh  = 12, rasterl  = 13;  /* monochrome cursor default raster lines */
  141.  
  142.  
  143. /*
  144. ** locals
  145. */
  146.  
  147. static int Initialized = 0;        /* are all the critical pointers set? */ 
  148.  
  149. static union REGS old_vid;
  150.  
  151. static int vid_seg  = 0xB000,      /* monochrome screen RAM base address */
  152.            vid_attr = 7,           /* HEAVILY USED HEREIN */
  153.            vid_page = 0,           /* "active" page is default (unused?) */ 
  154.            vid_wide = 80;          /* unused */
  155.  
  156. static char far *scribble;         /* transfer depot for RAM read/write */
  157. static char far *hidescreen;       /* pointer to invisible screen buffer */
  158.  
  159. static int activescreen = 0xB000, 
  160.            row = 0,
  161.            col = 0; 
  162.  
  163. static union REGS xy;              /* holds machine cursor address for set */
  164.  
  165. static int synchronized = 1;       /* default to hard & soft cursors alike */
  166.  
  167. static int lm = TOPX,
  168.            rm = BTMX,
  169.            tm = TOPY,
  170.            bm = BTMY;              /* default window margins */
  171.  
  172.  
  173.  
  174. /* H_pfill().  Pattern fill routine, hardwired to active screen, scribble.
  175. **
  176. ** Called by rptchar(), scrollup(), scrolldn().  Use with discretion
  177. ** because there is NO error checking!
  178. **
  179. ** Assumes scribble is already set, plus any number of other hardwired
  180. ** characteristics.  Generalizing this for any size of pattern source buffer
  181. ** and any size of destination fill buffer might be useful.
  182. **
  183. ** Movedata is very efficient.  I suspect it just sets up registers and
  184. ** then executes a single 8086 machine instruction to do the block move.  
  185. ** The result is instantaneous, at least to the proverbial naked orb.
  186. */
  187.  
  188. static void H_pfill( base, cnt ) int base, cnt;  
  189. {
  190.      static int width = 2;  /* hardwired pattern (scribble) size */
  191.  
  192.      cnt *= width;    /* translate number of pattern objects 
  193.                       ** to number of destination bytes 
  194.                       */
  195.  
  196.      /* SET PATTERN IN DEST BUFFER:  Write pattern at least once.
  197.      */
  198.      movedata( FP_SEG(scribble), FP_OFF(scribble), /* from */ 
  199.                activescreen, base,                 /* to   */
  200.                width);
  201.  
  202.      cnt -= width;                           /* one object already moved */
  203.      if (cnt > 0)                            /* shall we continue? */
  204.      {
  205.         /* ULTRAFAST PATTERN FILL:  A source byte moved to the destination
  206.         ** on iteration N extends the source pattern for iteration N+1.
  207.         */
  208.         movedata( activescreen, base,           /* srce (!)  */
  209.                   activescreen, base + width,   /* dest (!!) */
  210.                   cnt);
  211.      }
  212. }
  213.  
  214. static void setmchnloc(void); /* forward ref to static ROM-BIOS function, below */
  215.  
  216. void gotoxy( x, y ) /* 0,0 RELATIVE TO TOPLEFT CORNER OF CURRENT WINDOW! */
  217. int x, y;
  218. {
  219.  
  220.     y %= 1 + bm - tm;  /* mod number of lines in window */
  221.     x %= 1 + rm - lm;  /* mod number of columns in line */
  222.  
  223.     row = tm + y;      /* translate window-relative to fullscreen-absolute */
  224.     col = lm + x;
  225.  
  226.     if (synchronized)  /* update machine cursor? */
  227.         setmchnloc();
  228. } 
  229.  
  230.  
  231.  
  232.  
  233. /* Scroll functions honor the current window, and do not alter global
  234. ** col & row settings.  The window scrolls up or down one line at a time.
  235. **
  236. ** NOTICE:   The fresh, blank line which results from scrolling has the
  237. **           Normal (vid[0]) attribute.  If this "fixup" were not attempted,
  238. ** the line would have the attribute of the last character in the text which
  239. ** formerly occupied the lowest (or highest) line.  Either approach is wrong
  240. ** in some circumstances, but the Normal attribute should be correct in most
  241. ** cases.  Caller may either execute clreol() to repair the window line, or
  242. ** modify vid[0] prior to scrolling.
  243. */
  244.  
  245. void scrollup()  /* scroll current window up one line */
  246. {
  247.     register int i, b1;
  248.     auto int count, limit;
  249.  
  250.     if (!Initialized) vid_init(0);
  251.  
  252.     b1 = 2*(lm+(tm*80));           /* find top left corner of window */
  253.     limit = bm - tm;               /* and number of lines in window, less one */
  254.     count = 2*(1 + rm - lm);       /* width of line */
  255.  
  256.     for (i = 0; i < limit; i++)  /* move all contents up one line */
  257.     {
  258.         movedata( activescreen, b1 + 160,   /* source */
  259.                   activescreen, b1,         /* destination */
  260.                   count); 
  261.         b1 += 160;
  262.     }
  263.  
  264.     scribble[0] = SPC;           /* clear bottom line of window */
  265.     scribble[1] = vid[0];
  266.     H_pfill( 2*(lm+(bm*80)), 1 + rm - lm );
  267. }
  268.  
  269. void scrolldn()  /* scroll current window down one line */ 
  270. {
  271.     register int i, b1; 
  272.     auto int count, limit;
  273.  
  274.     if (!Initialized) vid_init(0);
  275.  
  276.     b1 = 2*(lm+(bm*80));           /* find bottom left corner of window */
  277.     limit = bm - tm;               /* and number of lines in window, less one */
  278.     count = 2*(1 + rm - lm);       /* width of line */
  279.  
  280.     for (i = 0; i < limit; i++)  /* move all contents down one line */
  281.     {
  282.         movedata( activescreen, b1 - 160,   /* source */
  283.                   activescreen, b1,         /* destination */
  284.                   count);
  285.         b1 -= 160;
  286.     }
  287.  
  288.     scribble[0] = SPC;           /* clear top line of window */
  289.     scribble[1] = vid[0];
  290.     H_pfill( 2*(lm+(tm*80)), 1 + rm - lm );
  291. }
  292.  
  293.  
  294.  
  295. void getwindow( tx, ty, bx, by )  /* read current window dimensions */
  296. int *tx, *ty, *bx, *by;
  297. {
  298.     *tx = lm;
  299.     *ty = tm;
  300.     *bx = rm;
  301.     *by = bm;
  302. }
  303.  
  304.  
  305. void setwindow( tx, ty, bx, by )
  306. int tx, ty, bx, by;
  307. {
  308.    if (bx > BTMX) bx = BTMX;
  309.    if (tx < TOPX) tx = TOPX;
  310.    if (by > BTMY) by = BTMY;
  311.    if (ty < TOPY) ty = TOPY;
  312.  
  313.    if (tx >= bx || ty >= by)  /* absurd values? set full screen reduced by 1 */
  314.    { 
  315.        putch(7); /* complain but continue */
  316.        lm = TOPX + 1; rm = BTMX - 1; tm = TOPY + 1; bm = BTMY - 1; 
  317.    } 
  318.    else
  319.    {
  320.        lm = tx;
  321.        rm = bx;
  322.        tm = ty;
  323.        bm = by;
  324.    }
  325. }
  326.  
  327.  
  328.  
  329.  
  330. void fullscreen()
  331. {
  332.    setwindow( TOPX, TOPY, BTMX, BTMY );
  333. }
  334.  
  335.  
  336.  
  337.  
  338. /*===========================*/
  339. /* screen character handlers */
  340. /*===========================*/
  341.  
  342. void setscreen( n ) int n;  /* set activescreen = 1 or 2, screen 1 is visible */
  343. {
  344.      if (!Initialized) vid_init(0);
  345.  
  346.      switch (n)
  347.      {
  348.          case 2:  { activescreen = FP_SEG( hidescreen ); break; }
  349.          default:
  350.          case 1:  { activescreen = vid_seg; break; }
  351.      }
  352. }
  353.  
  354.  
  355. void swapscreen( n ) int n;  /* swap hidden screen n with visible screen 1 */
  356. {                            /* for now, n can only be 2  */   
  357.      char far *save;
  358.      int tricseg, tracseg, saveseg, temp;
  359.  
  360.      if (!Initialized) vid_init(0);
  361.  
  362.      save = _fmalloc( SCRLIM );
  363.      saveseg = FP_SEG( save );
  364.  
  365.      temp = activescreen;
  366.  
  367.      if (n < 2) n = 2;       /* just now, range check on n is trivial */
  368.      if (n > 2) n = 2; 
  369.  
  370.      setscreen( n );              /* hidden screen n */
  371.         tracseg = activescreen;
  372.      setscreen( 1 );              /* visible screen 1 */ 
  373.         tricseg = activescreen;
  374.  
  375.      activescreen = temp;
  376.  
  377.      movedata( tracseg, 0, saveseg, 0, SCRLIM);  /* swap contents of screens */
  378.      movedata( tricseg, 0, tracseg, 0, SCRLIM);
  379.      movedata( saveseg, 0, tricseg, 0, SCRLIM);
  380.  
  381.      _ffree( save );
  382. }
  383.  
  384.  
  385.  
  386. void setsynch( on ) int on;  /* synchronized is ON by default */
  387. {
  388.      if ((synchronized = on? 1: 0) == 1)
  389.          setmchnloc();
  390. }
  391.  
  392.  
  393.  
  394.  
  395. void rptchar( ch, cnt ) char ch; int cnt;  /* does NOT update screen position */
  396. {
  397.      if (!Initialized) vid_init(0);
  398.  
  399.      scribble[0] = ch;
  400.      scribble[1] = vid_attr;
  401.      if (cnt >= 1) 
  402.          H_pfill( GOXY, cnt );  /* use pattern fill for speed */
  403. }
  404.  
  405.  
  406.  
  407. void readscreenchar( ch ) SCW *ch;
  408. {
  409.     if (!Initialized) vid_init(0);
  410.  
  411.     movedata( activescreen, GOXY,
  412.               FP_SEG(scribble), FP_OFF(scribble), 
  413.               2);
  414.     ch->byte = scribble[0];
  415.     ch->attr = scribble[1];
  416. }
  417.  
  418.  
  419.  
  420. /*============================*/
  421. /* screen clearing functions  */
  422. /*============================*/
  423.  
  424.  
  425.  
  426. void clreol()  /* honors current window setting */
  427. {
  428.     if (!Initialized) vid_init(0);
  429.  
  430.     rptchar(SPC, 1 + rm - col);
  431. }
  432.  
  433.  
  434. void clrwindow()   /* home cursor, clear window */
  435. {
  436.     int lin, yrel, xrel, temp;
  437.  
  438.     if (!Initialized) vid_init(0);
  439.  
  440.     temp = synchronized;
  441.     setsynch( 0 );        /* don't bother gotoxy with machine cursor updates */
  442.     lin = tm;
  443.     xrel = yrel = 0;
  444.     while (lin++ <= bm)
  445.     {
  446.         gotoxy(xrel, yrel++);
  447.         clreol();
  448.     }
  449.     gotoxy(0,0);
  450.     setsynch( temp );
  451. }
  452.  
  453.  
  454. void clreos()  /* screen only, ignores window */
  455. {
  456.     if (!Initialized) vid_init(0);
  457.     rptchar( SPC, (SCRLIM - GOXY) / 2 );
  458.  
  459. }
  460.  
  461.  
  462. void clrscrn()  /* resets full screen, homes cursor, clears screen */
  463. {
  464.     if (!Initialized) vid_init(0);
  465.  
  466.     fullscreen();
  467.     gotoxy(0,0);
  468.     rptchar(SPC,SCRLIM /2);
  469. }
  470.  
  471.  
  472. /*======================*/
  473. /* WindowBox            */
  474. /*======================*/
  475.  
  476. /* this version draws even the largest box almost instantaneously
  477. ** dco, 8/29/86
  478. */
  479.  
  480. void windowbox( tx, ty, bx, by ) int tx, ty, bx, by;
  481. {
  482.         register int i,j; 
  483.         auto int temp;
  484.  
  485.         if (!Initialized) vid_init(0);
  486.  
  487.         /* first, clear the working area to startle and amuse...
  488.         */
  489.  
  490.         setwindow( tx, ty, bx, by );
  491.         clrwindow();
  492.  
  493.         /* now, draw a crisp double-lined box (user's vid_attr ignored)
  494.         */
  495.  
  496.         temp = vid_attr;
  497.         vid_attr = (vid_mode == 2)? vid[15]: vid[10];
  498.  
  499.         tx = lm; /* use values that setwindow range checking may have found! */
  500.         ty = tm;
  501.         bx = rm;
  502.         by = bm;
  503.  
  504.         /* then, draw the border AROUND the area!
  505.         */
  506.  
  507.         fullscreen();        /* allows gotoxy to use the argument dimensions */
  508.  
  509.         if (tx > TOPX) { --tx; }
  510.         if (ty > TOPY) { --ty; }
  511.         if (bx < BTMX) { ++bx; }
  512.         if (by < BTMY) { ++by; }
  513.  
  514.         /* top line
  515.         */
  516.         gotoxy( tx, ty );
  517.         rptchar('═',bx - tx);
  518.  
  519.         /* right side
  520.         */
  521.         gotoxy( bx, ty );
  522.         rptchar('╗',1);
  523.  
  524.         j = by - ty;       /* put the for loop condition into a register int */
  525.         for ( i = 1; i < j; i++ )
  526.         {
  527.              gotoxy( bx, ty + i);
  528.              rptchar('║',1);
  529.         }
  530.  
  531.         /* bottom line 
  532.         */
  533.         gotoxy( bx, by );
  534.         rptchar('╝',1);
  535.  
  536.         gotoxy( tx, by );
  537.         rptchar('═',bx - tx);
  538.         rptchar('╚',1);
  539.  
  540.         /* left side
  541.         */
  542.         for ( i = 1; i < j; i++ )
  543.         {
  544.              gotoxy( tx, ty + i);
  545.              rptchar('║',1);
  546.         }
  547.  
  548.         gotoxy(tx,ty);
  549.         rptchar('╔',1);
  550.  
  551.         /* last, restore entry dimensions, with fixups on squashed margins
  552.         */
  553.  
  554.         /* Box is AROUND window    Window is squashed onto box's outline */
  555.         /* ---------------------   ------------------------------------- */
  556.            ++tx;                   /* else tx always was TOPX, so tx++;  */
  557.            ++ty;                   /* else ty always was TOPY, so ty++;  */
  558.            --bx;                   /* else bx always was BTMX, so bx--;  */
  559.            --by;                   /* else by always was BTMY, so by--;  */
  560.  
  561.         setwindow( tx, ty, bx, by );
  562.         gotoxy(0,0);
  563.         vid_attr = temp;  /* restore user's vid_attr */
  564. }
  565.  
  566.  
  567.  
  568.  
  569. void wink( c )  /* window character out, obeys backspace and newline */
  570. char c;
  571. {
  572.  
  573.     if (!Initialized) vid_init(0);
  574.  
  575.     /* newline? */
  576.     if (c == '\n' || c == '\r') col = 80;  /* set range err to force CR */
  577.  
  578.     /* backspace? nondestructive = 8, destructive = 127 */
  579.     else if ( c == '\b' || c == 127)  /* NOTICE:  THIS PATH RETURNS */
  580.     {
  581.         col--;               /* decrement the column */
  582.         if (col < lm)        /* beyond left margin? */
  583.         {
  584.              row--;          /* yes, decrement the line */
  585.              if (row < tm)   /* above top margin? */
  586.              {
  587.                 row = tm;    /* yes, stick at 0,0 -- does not scroll down! */
  588.                 col = lm;
  589.              }
  590.              else col = rm;  /* no, jump to rightmost column */ 
  591.         }
  592.         if (c == 127) rptchar(SPC,1); /* destroy existing char on screen    */
  593.         goto synch;
  594.     } 
  595.  
  596.     else rptchar( c, 1 );    /* uses vid_attr attribute */
  597.  
  598.     /* bump x cursor position, do newline or scroll window up if necessary */
  599.  
  600.     if ( col >= rm )      /* need to newline? */
  601.     {
  602.         col = lm;
  603.         if ( row >= bm )  /* need to scroll? */
  604.         {
  605.             row = bm;
  606.             scrollup();
  607.         }
  608.         else row++;
  609.     }
  610.     else col++;
  611.  
  612.     synch:
  613.     if (synchronized) /* update machine cursor */
  614.         setmchnloc();
  615.  
  616. } /* wink */
  617.  
  618.  
  619.  
  620.  
  621.  
  622. void wputs( p )  /* write string into window, uses wink */
  623. char *p;
  624. {
  625.      register int test;
  626.      auto int temp;
  627.  
  628.      if (!Initialized) vid_init(0);
  629.  
  630.      temp = synchronized;
  631.      setsynch(0);
  632.      while (*p) 
  633.      {
  634.          if (*p == '^')  /* escape character? switch modes */
  635.          {
  636.              p++;              /* read escape command char */
  637.              test = *p & 0xFF; /* kill sign extension */
  638.              switch ( test ) 
  639.              {
  640.                  case  '0': { vid_attr = vid[ 0]; break; }
  641.                  case  '1': { vid_attr = vid[ 1]; break; }
  642.                  case  '2': { vid_attr = vid[ 2]; break; }
  643.                  case  '3': { vid_attr = vid[ 3]; break; }
  644.  
  645.                  case  '4': { vid_attr = vid[ 4]; break; }
  646.                  case  '5': { vid_attr = vid[ 5]; break; }
  647.                  case  '6': { vid_attr = vid[ 6]; break; }
  648.                  case  '7': { vid_attr = vid[ 7]; break; }
  649.                  case  '8': { vid_attr = vid[ 8]; break; }
  650.                  case  '9': { vid_attr = vid[ 9]; break; }
  651.  
  652.                  case  'Ω': { vid_attr = vid[10]; break; } /* ea */
  653.                  case  'δ': { vid_attr = vid[11]; break; } /* eb */
  654.                  case  '∞': { vid_attr = vid[12]; break; } /* ec */
  655.                  case  'φ': { vid_attr = vid[13]; break; } /* ed */
  656.                  case  'ε': { vid_attr = vid[14]; break; } /* ee */
  657.                  case  '∩': { vid_attr = vid[15]; break; } /* ef */
  658.  
  659.                  case  '^': { 
  660.                             wink( *p );  /* verbatim ^ char */
  661.                             break; 
  662.                             }
  663.                  default:   { 
  664.                             --p; 
  665.                             vid_attr = vid[0];  /* just ^, no command arg */
  666.                             break; 
  667.                             }
  668.              }
  669.              p++;  /* next after escape command */
  670.          }
  671.          else 
  672.          {
  673.              wink( *p++ );  /* obeys newline, tab, if present */
  674.          }
  675.      }
  676.      setsynch(temp); /* update machine cursor only at last, if at all */
  677.  
  678. } /* wputs */
  679.  
  680.  
  681.  
  682. /*================================*/
  683. /*  ROM-BIOS dependent functions  */
  684. /*================================*/
  685.  
  686. static void setmchnloc(void)  /* the ROM-BIOS gotoxy function */
  687. {
  688.     xy.h.ah = 2;
  689.     xy.h.bh = 0;
  690.     xy.h.dh = row;
  691.     xy.h.dl = col;
  692.     int86( 0x10, &xy, &xy );
  693. }
  694.  
  695.  
  696. void setcursize( r1, r2 )
  697. int r1,r2;
  698. {
  699.     union REGS rx;
  700.  
  701.     rx.h.ah = 1;
  702.     rx.h.ch = r1;
  703.     rx.h.cl = r2;
  704.     int86( 0x10, &rx, &rx );
  705. }
  706.  
  707.  
  708. void defcursor()  /* set default cursor for cga or mono */
  709. {
  710.     setsynch(1);
  711.     setcursize( rasterh, rasterl );
  712. }
  713.  
  714.  
  715. /* The cursor save and restore routines recognize the synchronized flag.
  716. ** If synchronized, the machine cursor is saved or restored, and the soft
  717. ** cursor is identical to the machine cursor; if not synchronized, the
  718. ** soft cursor is saved or restored, and the machine cursor (wherever it
  719. ** happens to be) is ignored.
  720. **
  721. ** The value of the current synchronized flag is saved or returned:
  722. **
  723. **   Savecursor() returns the value of the synchronized flag, and saves it.
  724. **   Restcursor() returns the value of the synchronized flag that was active
  725. **                when the cursor was saved, but does not restore it.
  726. */
  727.  
  728. int savecursor( x )
  729. union REGS *x;
  730. {
  731.     if (synchronized)  /* hard and soft are identical, save hard */
  732.     {
  733.        x->h.ah = 3;
  734.        x->h.bh = 0;
  735.        int86( 0x10, x, x );
  736.     }
  737.     else               /* save soft */
  738.     {
  739.        x->h.dh = row;
  740.        x->h.dl = col;
  741.     }
  742.     x->h.ah = synchronized;  /* save the flag for proper kind of restore */
  743.     return( x->h.ah );
  744. }
  745.  
  746.  
  747. int restcursor( x )
  748. union REGS *x;
  749. {
  750.     if (x->h.ah != 0)        /* non-zero, synchronization was ON when saved */
  751.     {
  752.        x->h.ah = 1;          /* so restore machine size */
  753.        x->h.bh = 0;          /* ensure "active" page */
  754.        int86( 0x10, x, x );
  755.        x->h.ah = 2;          /* and machine location */
  756.        int86( 0x10, x, x );
  757.     }
  758.     row = x->h.dh;           /* in any case, set soft location to match */
  759.     col = x->h.dl;
  760.     return( x->h.ah );
  761. }
  762.  
  763.  
  764.  
  765. void hidecursor()
  766. {
  767.     setsynch(0);
  768.     setcursize( 32,32 );
  769. }
  770.  
  771.  
  772. /*
  773. **  ================================================
  774. **  Sample calls to savescreen(), restorescreen()
  775. **  Note:  These only work with text screens, 
  776. **  they do not save CRTpage/CPUpage screen info.
  777. **  They DO save the current window margins!
  778. **  ================================================
  779. **
  780. **   main() {
  781. **
  782. **   union REGS x,z;
  783. **   char far *screen1, *screen2;
  784. **
  785. **   vid_init();                            WARNING: must call vid_init()
  786. **   screen1 = savescreen( &x );
  787. **   .
  788. **   .
  789. **          screen2 = savescreen( &z );     WARNING: these MUST nest properly
  790. **          .                                        or heap allocation will
  791. **          .                                        be annihilated! 
  792. **          .
  793. **          restorescreen( screen2, &z );
  794. **   .
  795. **   .
  796. **   restorescreen( screen1, &x );
  797. **   }
  798. **
  799. */
  800.  
  801. static void sorry( n ) int n;
  802. {
  803.     char *p,*q;
  804.     q = "init";
  805.     switch (n)
  806.     {
  807.     case 2:  q = "restorescreen"; p = "no screen saved, can't restore"; break;
  808.     case 1:  q = "savescreen";
  809.     case 0:  p = "not enough k, can't continue"; break;
  810.     default: q = "nasty"; p = "looks fatal"; break;
  811.     } 
  812.     printf("\n\aCIAO: %s error: %s\n",q,p);
  813.     exit(1);
  814. }
  815.  
  816.  
  817. char far *savescreen( cursor )  /* caller must keep pointer to storage! */
  818. union REGS *cursor;
  819. {
  820.     union REGS ry;
  821.     char far *scrfptr;
  822.      
  823.     if (!Initialized) vid_init(0);
  824.  
  825.     ry.h.ah = 0x03;                   /* read cursor position...       */
  826.     ry.h.bh = 0;
  827.     int86( 0x10, &ry, cursor );       /* store result in caller's var  */
  828.  
  829.     cursor->x.cflag = 1066;           /* a famous date in history...   */
  830.     cursor->h.ah = tm;                /* save caller's window settings */
  831.     cursor->h.al = lm;                /* cannot use bx, cx or dx       */
  832.     cursor->x.di = rm;
  833.     cursor->x.si = bm;
  834.  
  835.     scrfptr = _fmalloc( SCRLIM );
  836.     if ( scrfptr == 0L )
  837.     {
  838.         sorry(1);
  839.     }
  840.     movedata( vid_seg, 0, FP_SEG( scrfptr ), FP_OFF( scrfptr ), SCRLIM );
  841.     return (scrfptr);
  842. }
  843.  
  844.  
  845.  
  846.  
  847. void restorescreen( scrfptr, cursor ) /* caller keeps pointer to storage! */
  848. char far *scrfptr;
  849. union REGS *cursor;
  850. {
  851.     union REGS rx;
  852.  
  853.     if (!Initialized || cursor->x.cflag != 1066)
  854.     {
  855.         sorry(2);
  856.     }
  857.  
  858.     movedata( FP_SEG( scrfptr ), FP_OFF( scrfptr ), vid_seg, 0, SCRLIM );
  859.     _ffree( scrfptr );
  860.  
  861.     tm = cursor->h.ah;        /* restore caller's window settings */
  862.     lm = cursor->h.al;
  863.     rm = cursor->x.di;
  864.     bm = cursor->x.si;
  865.     cursor->x.ax = cursor->x.si = cursor->x.di = cursor->x.cflag = 0;
  866.  
  867.     rx.h.ah = 1;
  868.     rx.x.bx = cursor->x.bx;
  869.     rx.x.cx = cursor->x.cx;     /* set old cursor size     */
  870.     int86( 0x10, &rx, &rx );
  871.     rx.h.ah = 2;
  872.     rx.x.bx = cursor->x.bx;
  873.     rx.x.dx = cursor->x.dx;
  874.     int86( 0x10, &rx, cursor ); /* set old cursor position */
  875. }
  876.  
  877.  
  878.  
  879.  
  880. /*
  881. ** Initialize, Deinitialize
  882. */
  883.  
  884. static void init_criticals(mode) int mode;
  885. {
  886.     int i;
  887.     union REGS rx;
  888.  
  889.     if (((scribble = (char far *) _fmalloc(2)) == 0L) ||
  890.        ((hidescreen  = (char far *) _fmalloc(SCRLIM)) == 0L)) 
  891.            sorry(0);
  892.  
  893.     rasterh  = 12;                 /* assume monochrome cursor */
  894.     rasterl  = 13;
  895.  
  896.     rx.h.ah = 15;                  /* read current video mode */
  897.     int86( 0x10, &rx, &old_vid );
  898.     vid_page = old_vid.h.bh;
  899.     vid_wide = old_vid.h.ah;
  900.     vid_mode = old_vid.h.al;   /* a 7 means we found monochrome hardware */
  901.  
  902.  
  903.     if (mode == 0) mode = vid_mode;  /* request to stay in current mode? */
  904.  
  905.     /* in any case, allow only mono mode 7, or cga modes 2 or 3 */
  906.  
  907.     if (vid_mode != 7)         /* is hardware a color/graphics adapter? */
  908.     {
  909.        vid_seg = 0xB800;       /* yes, screen RAM base address is different! */
  910.        if ( mode == 3 )        /* asking for color?  set it up! */
  911.        {
  912.           for (i = 0; i < 16; i++) 
  913.               vid[i] = i;                      /* set color defaults */
  914.           vid[0]  = 0x17 | 0x08;               /* set normal         */
  915.           vid[1]  = 0x06 | 0x08;               /*  "  bold           */
  916.           vid[2]  = 0x71 | 0x08;               /*  "  emphasis       */
  917.           vid[3]  = 0x47 | 0x08 | 0x80;        /*  "  attention      */
  918.        }
  919.        else 
  920.        {
  921.           mode = 2;                 /* only modes 2 and 3 are allowed, here */
  922.           for (i = 4; i < 16; i++)  /* all else defaults to normal */
  923.               vid[i] = vid[0];
  924.        }
  925.        rasterh = 6;               /* cga default cursor raster lines */
  926.        rasterl = 7;
  927.        if (vid_mode != mode)      /* not already in the requested mode? */
  928.        {
  929.           rx.h.ah = 0;            /* if not, set requested mode */
  930.           rx.h.al = mode;
  931.           int86( 0x10, &rx, &rx );
  932.        }
  933.        rx.h.ah = 15;              /* read current mode again */
  934.        int86( 0x10, &rx, &rx );
  935.        vid_page = rx.h.bh;        /* set globals accordingly */ 
  936.        vid_wide = rx.h.ah;
  937.        vid_mode = rx.h.al;
  938.     }
  939.     Initialized = 1;              /* we are, basically, but...  */
  940.     setscreen(1);                 /* ensure activescreen is set */
  941.     vid_attr = vid[0];            /* and ensure vid_attr is set */
  942. }
  943.  
  944.  
  945.  
  946.  
  947. /* Vid_Init() - This is a "MUST CALL", but if the various routines which
  948. **              depend on finding initialized values and pointers find the
  949. **              Initialized flag set to zero, they will take it on themselves
  950. **              to call vid_init(0).  Any argument to vid_init is valid, but
  951. **              mode 7 is set if the monochrome adapter is in the system, and
  952. **              only modes 2 or 3 are set if the cga card is found.  The 
  953. **              0 argument requests that a valid current mode not be changed;
  954. **              this prevents the firmware from clearing the screen, if it's
  955. **              not absolutely necessary.  Vid_init() will always select the
  956. **              visible screen, and synchronize the soft & machine cursors.
  957. **              Also, selects appropriate default cursor size; cga and mono
  958. **              have different cursors.
  959. */
  960.  
  961. void vid_init( mode ) int mode;
  962. {
  963.     auto union REGS x;
  964.  
  965.     init_criticals(mode);      /* sets initialized flag on exit */
  966.  
  967.     savecursor( &x );          /* We can now make sure that hard and   */
  968.     row = x.h.dh;              /* soft cursors actually are identical, */
  969.     col = x.h.dl;              /* going soft <- hard!  Otherwise, the  */
  970.     synchronized = 1;          /* first savescreen( &cursor ) doesn't! */
  971. }                              
  972.  
  973.  
  974.  
  975.  
  976. void vid_exit()
  977. {
  978.      if (Initialized)
  979.      {
  980.           if (old_vid.h.al != vid_mode)
  981.           {
  982.                old_vid.h.ah = 0;
  983.                int86( 0x10, &old_vid, &old_vid );
  984.           }
  985.           _ffree(hidescreen);
  986.           _ffree(scribble);
  987.           Initialized = 0;  /* we're NOT initialized any more! */
  988.      }
  989.      setcursize( rasterh, rasterl );
  990. }
  991.  
  992.  
  993. /* eof: ciao.c */
  994.  
  995.